package org.shoukaiseki.common.utils;

import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.ComparatorUtils;
import org.apache.commons.collections.comparators.ComparableComparator;
import org.apache.commons.collections.comparators.ComparatorChain;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 *
 **/
public class ListOrderBy<T> {

    private List<T> list;

    ArrayList<Object> sortFields = new ArrayList<Object>();


    public static <T> ListOrderBy<T> orderBy(List<T> list) {
        return orderBy(list, true);
    }

    /**
     *
     * @param list
     * @param newList   true: 创建一个新的 list 用于排序
     */
    public static <T> ListOrderBy<T> orderBy(List<T> list, boolean newList) {
        return new ListOrderBy<T>(list,newList );
    }

    private ListOrderBy(List<T> list, boolean newList){
        if(newList){
            this.list=ListUtils.copyToList(list);
        }else{
            this.list=list;
        }
    }

    /**
     * 顺序 null 在 list 最后
     * @param sortKey
     * @return
     */
    public ListOrderBy<T> aesNullEnd(String sortKey){
        return addOrder(sortKey,false,true);
    }

    /**
     * 顺序 null 在 list 最前
     * @param sortKey
     * @return
     */
    public ListOrderBy<T> aesNullFirst(String sortKey){
        return addOrder(sortKey,false,false);
    }

    /**
     * 倒序 null 在 list 最后
     * @param sortKey
     * @return
     */
    public ListOrderBy<T> descNullEnd(String sortKey){
        return addOrder(sortKey,true,true);
    }

    /**
     * 倒序 null 在 list 最前
     * @param sortKey
     * @return
     */
    public ListOrderBy<T> descNullFirst(String sortKey){
        return addOrder(sortKey,true,false);
    }



    /**
     * @param sortKey    要排序的字段
     * @param desc       true: 倒序
     * @param nullEnd    true: null 在 list 最后, null在 list 最前
     * @return
     */
    public ListOrderBy<T> addOrder(String sortKey,boolean desc,boolean nullEnd){
        Comparator comparator = ComparableComparator.getInstance();
        if(desc){
            //逆序
            comparator= ComparatorUtils.reversedComparator(comparator);
        }
        if(nullEnd){
            //null 在 list 最后
            comparator= ComparatorUtils.nullHighComparator(comparator);
        }else{
            //null 在 list 最前
            comparator= ComparatorUtils.nullLowComparator(comparator);
        }
        sortFields.add(new BeanComparator(sortKey, comparator));
        return this;
    }

    public List<T> sort(){
        // 创建一个排序链
        ComparatorChain multiSort = new ComparatorChain(sortFields);
        // 开始真正的排序，按照先主，后副的规则
        Collections.sort(list, multiSort);
        return list;
    }
}
